home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / DNet / DGoList.cpp < prev    next >
Text File  |  1996-07-05  |  29KB  |  1,120 lines
  1. // DGopherList.cp 
  2. // by d.g. gilbert, Mar 1992 
  3. // dclap version jan 94
  4. /*
  5.             This code is Copyright (C) 1992 by D.G. Gilbert.
  6.             All Rights Reserved.
  7.  
  8.             You may use this code for your personal use, to provide a non-profit
  9.             service to others, or to use as a test platform for a commercial
  10.             implementation. 
  11.  
  12.             You may not use this code in a commercial product, nor to provide a
  13.             commercial service, nor may you sell this code without express
  14.             written permission of the author.  
  15.             
  16.             gilbertd@bio.indiana.edu 
  17.             Biology Dept., Indiana University, Bloomington, IN 47405 
  18. */
  19.  
  20.  
  21. #include <ncbi.h>
  22. #include <dgg.h>
  23.  
  24. #include "DTCP.h"
  25. #include "DGopher.h"
  26. #include "DURL.h"
  27. #include "DGoList.h"
  28. #include "DGoPlus.h"
  29. #include "DGoInit.h"
  30. #include "DGoClasses.h"
  31.  
  32. #include <DList.h>
  33. //#include <DView.h>
  34.  
  35. // this dup's DGopher.cpp ! Beware -- need public const DGopher::kLocalhost
  36. Local const char* kLocalhost = "localhost";
  37.  
  38.  
  39. // DGopherList ------------------------------
  40.  
  41. #define Inherited DList
  42.  
  43. // static
  44. short dglCompareGophers( DGopher* gopher1, DGopher* gopher2)
  45. {
  46.     if ( gopher1->Equals( gopher2) ) 
  47.         return 0;
  48. #if 0
  49.     char*    name1= (char*) (gopher1)->GetName();
  50.     char*    name2= (char*) (gopher2)->GetName();
  51.     short val= StrICmp( name1, name2);
  52.     if (val) return val;
  53. #endif
  54.     else if (gopher1 > gopher2) return 1;
  55.     else return -1;
  56. } 
  57.  
  58.  
  59. DGopherList::DGopherList(  DGopher* parentMenu) :
  60.     DList(),             //::dglCompareGophers),  // comparitor !?
  61.     fStatusLine(NULL),
  62.     fNewGopher(NULL),
  63.     fListUnknowns(gListUnknowns),
  64.     fSortOrder(kSortByItem),
  65.     fParentMenu(parentMenu)
  66. {
  67.     gNeedTypeChange= false;
  68. }
  69.  
  70. void DGopherList::FreeAllObjects()
  71. {
  72.     long i, n= this->GetSize();
  73.     for (i= 0; i<n; i++) {
  74.         DGopher* obj= GopherAt(i);
  75.         if (obj->GetOwnerCount() <= 1) delete obj;
  76.         else obj->suicide(); // this alone doens't call obj destructors !!
  77.         }
  78.     this->DeleteAll();
  79. } 
  80.  
  81. Boolean DGopherList::suicide(void) 
  82. { 
  83.     if (GetOwnerCount() <= 1) { 
  84.         delete this; 
  85.         return true; 
  86.         }
  87.     else 
  88.         return DObject::suicide();
  89. }
  90.  
  91. Boolean DGopherList::suicide(short ownercount)
  92. {
  93.     if (ownercount < 1) {
  94.         delete this; 
  95.         return true; 
  96.         }
  97.     else 
  98.         return DObject::suicide(ownercount);
  99. }
  100.  
  101. void DGopherList::SetStatus(DView *statusline)
  102. {
  103.     fStatusLine= statusline;
  104. }
  105.  
  106.  
  107. // static
  108. DGopher* DGopherList::NewGopher(char itemType, char* info, char* plusinfo,
  109.      short& status, DGopherList* ownerList)
  110. {
  111.     DGopher*    theGopher= NULL;
  112.     short        isPlus = status;
  113.     Boolean    hasAsk = false;
  114.     
  115.     status= DGopher::kNewGopherOkay;
  116.         /* Recursion note: could this sometimes lead to inf. loop w/ wrong choice
  117.             of server && local gopher types? */
  118.  
  119.     if (itemType == '+') {
  120.         // ?? a read error on gopher+ item ...
  121.         }
  122.  
  123.     if (gDoSuffix2MacMap && gGopherMap) {
  124.         DGopherMap* mapper= gGopherMap->MatchGopherType( itemType, false);
  125.         if (mapper) itemType= mapper->fLocalType;
  126.         }
  127.  
  128.     switch (itemType) {
  129.         case kTypeNull:
  130.         case kTypeEndOfData    :  
  131.             theGopher= NULL;
  132.             status= DGopher::kNewGopherEnd;  //'.', end of information 
  133.             break;
  134.             
  135.         case kTypeFile       : theGopher= new DTextGopher; break;
  136.         case kTypeFolder    : theGopher= new DFolderGopher; break;
  137.         case kTypeQuery   : theGopher= new DIndexGopher; break;
  138.         case kTypeBinhex    : theGopher= new DBinhexGopher; break;
  139.         case kTypeTelnet  : theGopher= new DTelnetGopher; break;
  140. #if FIX_LATER
  141.         case kTypeUuencode: theGopher= new DUuencodeGopher; break;
  142.         case kTypeCSO            : theGopher= new DCSOPhoneBookGopher; break;
  143.         case kTypeWhois        : theGopher= new DWhoisPhoneBookGopher; break;
  144. #endif // FIX_LATER
  145.         case kTypeBinary  : theGopher= new DBinaryGopher; break;
  146.         case kTypeSound     : theGopher= new DSoundGopher; break;
  147.         case kTypeGif            :             
  148.         case kTypeImage        : theGopher= new DImageGopher; break;
  149.         case kTypeMovie        : theGopher= new DMovieGopher; break;
  150.         case kTypeNote        : theGopher= new DNoteGopher; break;
  151.         case kMailType        : theGopher= new DMailGopher; break;
  152.         case kTypeHtml       : theGopher= new DHtmlGopher; break;
  153.         //case kTypeTn3270     : theGopher= new DTN3270Gopher; break;
  154.         //case kTypeMime       : theGopher= new DGopher; break;
  155.         //case kTypeBinhexpc: theGopher= new DGopher; break;
  156.  
  157.         case kTypeError :      
  158.         default    : 
  159.             if (gListUnknowns) theGopher= new DGopher;  
  160.             else {
  161.                 theGopher= NULL;
  162.                 status= DGopher::kNewGopherNone;
  163.                 }
  164.             break;
  165.         }
  166.  
  167.     if (status == DGopher::kNewGopherOkay && info) { 
  168.         theGopher->SetLink( itemType, info);
  169.         if (theGopher->fIplus) {   
  170.             char *pp= theGopher->fLink + theGopher->fIplus; 
  171.             hasAsk= (*pp == '?');
  172.             if (hasAsk || *pp == '+' || *pp == '#') isPlus= kGopherPlusYes;
  173.             }
  174.         theGopher->SetOwner( ownerList);  
  175.         theGopher->SetPlusInfo( isPlus, hasAsk, plusinfo);
  176.         
  177.         if (theGopher->fIpath == 0 && theGopher->fIhost == 0) {
  178.             delete theGopher; 
  179.             theGopher= NULL;
  180.             status= DGopher::kNewGopherNone;
  181.             }
  182.         else if (gNeedTypeChange) {  
  183.             // Recursion alert: CopyToNewKind calls back NewGopher, but not to here...info==nil
  184.           DGopher* bGopher= 
  185.               DGopherList::CopyToNewKind( theGopher->fType, theGopher, ownerList);
  186.           if (bGopher!=NULL) {
  187.                 delete theGopher; 
  188.                 theGopher= bGopher;
  189.                 }
  190.             }
  191.          gNeedTypeChange= false; 
  192.         }
  193.     return theGopher;    
  194. }
  195.  
  196.  
  197. // static
  198. DGopher* DGopherList::CopyToNewKind(char itemType, DGopher* srcGopher, 
  199.                                     DGopherList* ownerList, Boolean copyMacStuff)
  200. {
  201.     short    status = srcGopher->fIsPlus;
  202.     DGopher* destGopher= DGopherList::NewGopher( itemType, NULL, NULL, status, ownerList);
  203.     if (status == DGopher::kNewGopherOkay) {
  204.             //destGopher->SetLink( itemType, *srcGopher->fLink);
  205.         destGopher->CopyGopher( srcGopher);
  206.  
  207.             // THIS IS a QUICK FIX for moving srcGopher to destGopher + delete srcGopher...
  208.             // this code is probably no longer needed, as we clone fViews,fAskers in CopyGopher
  209.         if (srcGopher->fViews && !destGopher->fViews) { 
  210.             destGopher->fViews= srcGopher->fViews; 
  211.             srcGopher->fViews= NULL;
  212.             }
  213.         if (srcGopher->fAskers && !destGopher->fAskers) { 
  214.             destGopher->fAskers= srcGopher->fAskers; 
  215.             srcGopher->fAskers= NULL;
  216.             }
  217.         if (srcGopher->fAbstract && !destGopher->fAbstract) { 
  218.             destGopher->fAbstract= srcGopher->fAbstract; 
  219.             srcGopher->fAbstract= NULL;
  220.             }
  221.         
  222.             // !! Need to change VIEW types to coincide w/ this (e.g., from text/plain to app/...)
  223.         destGopher->fType= itemType;
  224.         if (itemType != srcGopher->fType) {
  225.             destGopher->DeleteViews();
  226.             }
  227.  
  228.         if (copyMacStuff) {
  229.             destGopher->fTransferType    = srcGopher->fTransferType;  
  230.             destGopher->fMacType    = srcGopher->fMacType;              
  231.             destGopher->fMacSire    = srcGopher->fMacSire;     
  232.             destGopher->fSaveToDisk    = srcGopher->fSaveToDisk;     
  233.             destGopher->fLaunch        = srcGopher->fLaunch;     
  234.             }
  235.  
  236.         return destGopher;
  237.         }    
  238.     else
  239.         return NULL;    
  240. }
  241.  
  242.  
  243. // static
  244. short DGopherList::CompareGophers( void* gopher1, void* gopher2)
  245. {
  246.     if ( ((DGopher*) gopher1)->Equals( (DGopher*) gopher2) ) 
  247.         return 0;
  248.  
  249.     char*    name1= (char*) ((DGopher*)gopher1)->GetName();
  250.     char*    name2= (char*) ((DGopher*)gopher2)->GetName();
  251.     short val= StrICmp( name1, name2);
  252.     if (val) return val;
  253.     else if (gopher1 > gopher2) return 1;
  254.     else return -1;
  255. } 
  256.  
  257.  
  258.  
  259. short dglCompareByType( void* item1, void* item2)
  260. {
  261.     char    name1= ((DGopher*)item1)->fType;
  262.     char    name2= ((DGopher*)item2)->fType;
  263.     if (name1 < name2) return -1;
  264.     else if (name1 > name2) return 1;
  265.     else  return 0;
  266. }
  267.  
  268.  
  269. short dglCompareBySize( void* item1, void* item2)
  270. {
  271.     // We want INVERTED sort -- greatest size first
  272.     unsigned long    name1= ((DGopher*)item1)->fSizeLong;
  273.     unsigned long    name2= ((DGopher*)item2)->fSizeLong;
  274.     if (name1 > name2) return -1;
  275.     else if (name1 < name2) return 1;
  276.     else  return 0;
  277. }
  278.  
  279. short dglCompareByDate( void* item1, void* item2)
  280. {
  281.     // We want INVERTED sort -- greatest date first
  282.     unsigned long    name1= ((DGopher*)item1)->fDateLong;
  283.     unsigned long    name2= ((DGopher*)item2)->fDateLong;
  284.     if (name1 > name2) return -1;
  285.     else if (name1 < name2) return 1;
  286.     else  return 0;
  287. }
  288.  
  289. short dglCompareByHost(void* item1, void* item2)
  290. {
  291.     char*    name1= (char*) ((DGopher*)item1)->GetHost();
  292.     char*    name2= (char*) ((DGopher*)item2)->GetHost();
  293.     return StrICmp( name1, name2);
  294. }
  295.  
  296. short dglCompareByName( void* item1, void* item2)
  297. {
  298.     char*    name1= (char*) ((DGopher*)item1)->GetName();
  299.     char*    name2= (char*) ((DGopher*)item2)->GetName();
  300.     return StrICmp( name1, name2);
  301. }
  302.  
  303.  
  304. Boolean DGopherList::SortList(Sorts sortorder)
  305. {
  306.     if (sortorder == fSortOrder)
  307.         return false;
  308.     else {
  309.         fSortOrder= sortorder;
  310.         switch( sortorder) {
  311.             case kSortByKind :
  312.                 this->SortBy( dglCompareByType);
  313.                 break;
  314.             case kSortBySize : 
  315.                 this->SortBy( dglCompareBySize);
  316.                 break;
  317.             case kSortByDate :
  318.                 this->SortBy( dglCompareByDate);
  319.                 break;
  320.             case kSortByHost : 
  321.                 this->SortBy( dglCompareByHost);
  322.                 break;
  323.             case kSortByName : 
  324.                 this->SortBy( dglCompareByName);
  325.                 break;
  326.             case kSortByItem: 
  327.             default:
  328.                 this->Sort();
  329.                 break;
  330.             }
  331.         return true;
  332.         }
  333. }
  334.  
  335.  
  336.  
  337. Boolean DGopherList::MakeNewGopher( char *pInfo, char *eInfo, 
  338.                                                     char *pPlus, char *ePlus, short status)
  339. {
  340.     char    termInfo, termPlus;
  341.     if (eInfo) { termInfo= *eInfo; *eInfo= 0; }
  342.     if (ePlus) { termPlus = *ePlus; *ePlus= 0;  } 
  343.     fNewGopher= DGopherList::NewGopher( *pInfo, pInfo, pPlus, status, this);
  344.     if (eInfo) *eInfo= termInfo;
  345.     if (ePlus) *ePlus= termPlus;
  346.     switch (status) {
  347.         case DGopher::kNewGopherEnd : return false;
  348.         case DGopher::kNewGopherNone: return true; 
  349.         case DGopher::kNewGopherOkay: this->InsertLast( fNewGopher); return true;
  350.         }
  351.     return false;
  352. }
  353.  
  354.  
  355.  
  356. Boolean DGopherList::IsGopherLine( char *line)
  357. {
  358.     // this is a static function, usable w/o a DGopherListDoc object
  359.     // look for something like ( | == tab)
  360.     // start w/ optional "+INFO: "
  361.     // 1Any title string|optional path string|required host string|required port string|optional +
  362.     enum { kTitle, kPath, kHost, kPort, kPlus };
  363.     const short    kTabsInGopherItem = 3;
  364.  
  365.     char *np, *ep, *cp = line;
  366.     np= StrChr( cp, '\n'); 
  367.     if (!np) np= StrChr( cp, '\r');
  368.     if (!np) np= StrChr( cp, '\0'); // ?? or return false here
  369.     for (short itab=0; itab<kTabsInGopherItem; itab++) {
  370.         if ( (ep= StrChr( cp, '\t')) == NULL) 
  371.             return false;
  372.         else if (ep > np)
  373.             return false;
  374.         else switch (itab) {
  375.             case kTitle: if (ep < cp+2) return false; break;
  376.             case kPath: break; // can be null
  377.             case kHost: break; //<< null here in error type... //if (ep < cp+2) return false;
  378.             case kPort: if (ep < cp+1) return false; break;
  379.             }
  380.         cp = ep+1;
  381.         }
  382.     return true;
  383. }
  384.  
  385.  
  386. // static
  387. DGopher* DGopherList::GopherFromURL( char* url, long urlsize, 
  388.                                                     DGopherList* itsList, Boolean doInsertLast, char itemType)
  389. {
  390.     short    status;
  391.     char    calltype;
  392.     char *info = "0Link from URL\t0localdoc\tlocalhost\t70";
  393.     char *plusinfo = NULL;
  394.     DGopher* theGo;
  395.     
  396.     calltype= itemType;
  397.     if (!itemType) itemType= '0';
  398.     theGo= DGopherList::NewGopher( itemType, info, plusinfo, status, itsList);
  399.     switch (status) {
  400.  
  401.         case DGopher::kNewGopherOkay: {
  402.                 char oldtype= theGo->fType; 
  403.                 if (DURL::ParseURL( theGo, url, urlsize, true)) {
  404.                   if (calltype) 
  405.                         theGo->fType= calltype;
  406.                     else if (theGo->fType != oldtype) {
  407.                         DGopher* bGopher= 
  408.                             DGopherList::CopyToNewKind( theGo->fType, theGo, itsList);
  409.                       if (bGopher) {
  410.                             delete theGo; 
  411.                             theGo= bGopher;
  412.                             }
  413.                         }
  414.                     if (doInsertLast && itsList) itsList->InsertLast( theGo); 
  415.                     }
  416.                 else {
  417.                     delete theGo; 
  418.                     theGo= NULL;
  419.                     }    
  420.                 }
  421.                 break;
  422.  
  423.         case DGopher::kNewGopherEnd :  
  424.         case DGopher::kNewGopherNone: 
  425.                 if (theGo) delete theGo; 
  426.                 theGo= NULL;
  427.                 break;
  428.         }
  429.     if (itsList) itsList->fNewGopher= theGo;
  430.     return theGo;
  431. }
  432.  
  433. // static
  434.  
  435. DGopher*  DGopherList::LocalGopher( char* name)
  436. {    
  437.     char docurl[1024];
  438.     DGopher* theGo= NULL;
  439.     char   quote= '\'';    
  440.     if (StrChr( name, quote)) quote= '"';
  441.     StrCpy(docurl, " file:///");
  442.     StrNCat(docurl, name, 1000);
  443.     StrNCat(docurl, " ", 1000); 
  444.     docurl[1023]= 0;
  445.     long doclen= StrLen(docurl);
  446.     docurl[0]= quote; // so parseURL doesn't eat spaces
  447.     docurl[doclen-1]= quote;
  448.     theGo= DGopherList::GopherFromURL( docurl, doclen, NULL, false, 0);
  449.     if (theGo) theGo->StoreName( (char*)gFileManager->FilenameFromPath(name));
  450.     return theGo;
  451. }
  452.  
  453. DGopher*  DGopherList::LocalGopher( DFile* theFile)
  454. {    
  455.     return LocalGopher(  (char*) theFile->GetName());
  456. }
  457.  
  458.  
  459.  
  460.  
  461.  
  462. void DGopherList::ReadLinks( char* linkptr)
  463. {    
  464.     if (!linkptr) return;
  465.     ReadLinks( linkptr, StrLen(linkptr));
  466. }
  467.  
  468. void DGopherList::ReadLinks( char *linkptr, long len)
  469. {
  470.     Boolean done= false, haveinfo= false;
  471.     register char     *cp, *ci;
  472.     char        *cpend, *ep= NULL, *pInfo= NULL, *eInfo= NULL, *pPlus= NULL;
  473.     short     pluskind = kGopherPlusDontKnow;
  474.     
  475.             // ?? parse different possible formats:
  476.             //    \n+INFO: 
  477.             //  \n?...name...\t...path...\t...host...\t...#port...+maybe more\n
  478.             //  \nName=...\nHost=...\nPath=...\nPort=...\nType=...\nOther=
  479.             //    URL:? &/or   gopher://   or  ftp://  or other://
  480.             //
  481.             // ? some gopher+ server fails to send CR-LF, just sends LF ?!?
  482.             // also check for 3 tabs in first/info line -- skip till found to avoid bad data
  483.             // from some stupid servers.
  484.             
  485.     if (!linkptr) return;
  486.     cp= pInfo= linkptr;
  487.     cpend= cp + len; //-1;  
  488.     Boolean isPlus= (*cp == '+');
  489.  
  490.     while (!done && cp) {
  491.         ep= cp;
  492.         while (*cp < ' ' && *cp != 0 && cp != cpend) cp++;    // leave leading spaces in line !?!!
  493.         if (*cp == 0 || cp == cpend) done= true; // break;  !! need to process data yet
  494.         if (*cp == '+' && (*ep == kCR || *ep == kLF) && 0 == Strncasecmp( cp, "+INFO:", 6)) 
  495.               isPlus= true; 
  496.  
  497.         if (isPlus) {
  498.             Boolean atinfo = (0 == Strncasecmp( cp, "+INFO:", 6) );
  499.             
  500.             if (haveinfo && (atinfo || done)) {
  501.                 char* ePlus= (ep > pPlus) ? ep : pPlus;
  502.                 pluskind = kGopherPlusDontKnow; //kGopherPlusYes
  503.                 if (! MakeNewGopher( pInfo, eInfo, pPlus, ePlus, pluskind))  
  504.                     done= true; 
  505.                 haveinfo= false;
  506.                 pInfo= eInfo= pPlus= NULL;
  507.                 }
  508.             
  509.             if (done) 
  510.                 break; // nada
  511.                 
  512.             else if (atinfo) {
  513.                 haveinfo= true;
  514.                 cp += 6;
  515.                 while (*cp <= ' ' && *cp != 0 && cp != cpend) cp++;
  516.                 pInfo= cp;
  517.                 //eInfo= strchr(pInfo, kCR); if (!eInfo) eInfo= strchr(pInfo, kLF);
  518.                 for (ci= pInfo, eInfo= NULL; ci<cpend && *ci!=0; ci++) 
  519.                     if (*ci == kCR || *ci == kLF) { eInfo= ci; ci= cpend;}
  520.                         
  521.                 if (eInfo) {
  522.                     pPlus= eInfo+1; 
  523.                     while (*pPlus <= ' ' && *pPlus != 0 && pPlus != cpend) pPlus++;
  524.                     }
  525.                 else pPlus= NULL;
  526.                 }
  527.      
  528.             else if (*cp != '+' && *cp != ' ') { 
  529.                     // this may be Directory- list from gopher+ server
  530.                 char    *tp = NULL, *lastt;
  531.                 short  itab = 0;
  532.                 for (ci= cp; ci<cpend && *ci!=0; ci++) if (*ci == '\t') { tp= ci; ci= cpend; }
  533.                 if (tp) {
  534.                     lastt = tp+1;
  535.                     for (itab=0; itab<4 && tp!=NULL; itab++) { 
  536.                         lastt= tp+1; 
  537.                         tp= NULL;
  538.                         for (ci= lastt; ci<cpend && *ci!=0; ci++) if (*ci == '\t') { tp= ci; ci= cpend; }
  539.                         }
  540.                     }
  541.                 if (itab>2) {
  542. #if 1
  543.                     pluskind =kGopherPlusDontKnow;
  544. #else
  545.                     if (itab > 3 && *lastt == '+') pluskind = kGopherPlusYes;
  546.                     else pluskind = kGopherPlusNo;
  547. #endif
  548.                     pInfo= cp;
  549.                     for (ci= pInfo, eInfo= NULL; ci<cpend && *ci!=0; ci++) 
  550.                         if (*ci == kCR || *ci == kLF) { eInfo= ci; ci= cpend;}
  551.                     if (! MakeNewGopher( pInfo, eInfo, NULL, NULL, pluskind)) done= true;        
  552.                     }
  553.                 }
  554.  
  555.             }
  556.             
  557.         else if (done) 
  558.                 break; 
  559.                 
  560.         else if (IsGopherLine( cp)) {
  561.             pInfo= cp;
  562.             pluskind =kGopherPlusDontKnow;
  563.             for (ci= pInfo, eInfo= NULL; ci<cpend && *ci!=0; ci++) 
  564.                 if (*ci == kCR || *ci == kLF) { eInfo= ci; ci= cpend;}
  565.             if (! MakeNewGopher( pInfo, eInfo, NULL, NULL, pluskind))
  566.                 done= true;        
  567.             }
  568.  
  569.         else if (0 == Strncasecmp( cp, "+URL:", 5) ) {
  570.             cp += 5;
  571.             for (ci= cp, eInfo= NULL; ci<cpend && *ci!=0; ci++) 
  572.                 if (*ci == kCR || *ci == kLF) { eInfo= ci; ci= cpend;}
  573.             char* saven= StrDup( (char*)fNewGopher->GetName());
  574.             if (eInfo && DURL::ParseURL( fNewGopher, cp, eInfo-cp)) ;
  575.             if (saven && *saven) fNewGopher->StoreName(saven); 
  576.             MemFree(saven);
  577.             }
  578.  
  579.         //cp= strchr(cp, kCR); if (!cp) cp= strchr(cp, kLF);
  580.         for (ci= cp, cp= NULL; ci<cpend && *ci!=0; ci++) 
  581.             if (*ci == kCR || *ci == kLF) { cp= ci; ci= cpend;}
  582.         }
  583. }
  584.  
  585.  
  586.  
  587. char* DGopherList::WriteLinks(short indent)
  588. {
  589.     char*     h= (char*) MemGet(1,true);
  590.     long i, n= this->GetSize();
  591.     for (i= 0; i<n; i++) {
  592.         DGopher* ag= (DGopher*) this->At(i);
  593.         ag->ToText(h, indent);
  594.         }
  595.     return h;
  596. }
  597.  
  598.  
  599.  
  600. char* DGopherList::WriteLinksForServer()
  601. //Note: cannot currently READ this format -- .link form on unix servers 
  602. {
  603.     short        itemnum= 0;
  604.     char*     h= (char*) MemGet(1,true);
  605.     long i, n= this->GetSize();
  606.     for (i= 0; i<n; i++) {
  607.         DGopher* ag= (DGopher*) this->At(i);
  608.         ag->ToServerText(h, i+1);
  609.         }
  610.     return h;
  611. }
  612.  
  613.  
  614. char* DGopherList::WriteLinksForDisplay( 
  615.                 Boolean showDate, Boolean showSize, Boolean showKind, Boolean showPath, 
  616.                 Boolean showHost, Boolean showPort, Boolean showAdmin) // pretty print
  617. {
  618.     short        itemnum= 0;
  619.     char*     h= (char*) MemGet(1,true);
  620.     long i, n= this->GetSize();
  621.     for (i= 0; i<n; i++) {
  622.         DGopher* ag= (DGopher*) this->At(i);
  623.         ag->ToPrettyText( h, i+1, 
  624.                 showDate, showSize, showKind,
  625.                 showPath, showHost, showPort, showAdmin);
  626.         }
  627.     return h;
  628. }
  629.  
  630.  
  631.  
  632.  
  633.  
  634.  
  635.  
  636.  
  637.  
  638. #ifdef OS_MAC
  639.  
  640. #ifndef __TYPES__
  641. #include <Types.h>
  642. #endif
  643. #ifndef __MEMORY__
  644. #include <Memory.h>
  645. #endif
  646. #ifndef __OSUTILS__
  647. #include <OSUtils.h>
  648. #endif
  649. #ifndef __FILES__
  650. #include <Files.h>
  651. #endif
  652. #ifndef __FOLDERS__
  653. #include <Folders.h>
  654. #endif
  655.  
  656. #endif
  657.  
  658. #if defined(OS_DOS) || defined (OS_NT)
  659. #include <dir.h>
  660. #include <dos.h>
  661. #include <io.h>
  662. #endif
  663.  
  664. #ifdef OS_UNIX
  665. #include <dirent.h>
  666. #include <unistd.h>
  667. #endif
  668.  
  669.  
  670. class DLoGoInfo : public DObject
  671. {
  672. public:
  673.     char    fKind;
  674.     char * fName, * fDate, * fView;
  675.     const char * fTitle;
  676.     long    fSize;
  677.     Boolean fPlus, fIsAsk, fHasAbs;
  678.     DLoGoInfo(char kind, const char* name, const char* title, 
  679.                         const char* view, const char* date, long size) {
  680.         fKind= kind;
  681.         fSize= size;
  682.         fView= (char*) view; // note no StrDup
  683.         fName= StrDup(name);
  684.         if (title) fTitle= title; else fTitle= fName;
  685.         fDate= StrDup(date);
  686.         fPlus= true;
  687.         fIsAsk= fHasAbs= false;
  688.         }
  689.     ~DLoGoInfo() {
  690.         MemFree(fName);
  691.         MemFree(fDate);
  692.         }
  693. };
  694.  
  695.  
  696. short dglLoGoCompareByName( void* item1, void* item2)
  697. {
  698.     char*    name1= (char*) ((DLoGoInfo*)item1)->fTitle; //fName;
  699.     char*    name2= (char*) ((DLoGoInfo*)item2)->fTitle; //fName;
  700.     return StrICmp( name1, name2);
  701. }
  702.  
  703.  
  704. Local void StoreLoGoWais( short startwais, short endwais, DList* dirlist)
  705. {
  706.     short     j;
  707.     char    * suf;
  708.     DLoGoInfo * jinfo;
  709.     
  710.     jinfo= (DLoGoInfo*) dirlist->At(startwais);
  711.     jinfo->fKind= kTypeQuery;
  712.     jinfo->fView= "application/gopher-menu"; //???
  713.     //jinfo->fPlus= false; // ?? so app doesn't query for view info
  714.     suf= StrRChr( jinfo->fName, '.');
  715.     if (suf) *suf= 0;
  716.     for (j= startwais+1; j<endwais; j++) {
  717.         jinfo= (DLoGoInfo*) dirlist->At(j);
  718.         jinfo->fKind= 0;
  719.         }
  720.     //nwais= 0;
  721. }
  722.  
  723.  
  724. // static
  725. short DGopherList::LocalFolder2GopherList( DFile* outFile, char* folderpath)
  726. {
  727.     DList* dirlist= NULL;
  728.     DLoGoInfo* info;
  729.     char    namestore[256], pathstore[256], *nameat, buf[512];
  730.     long    pathlen, date, ksize;
  731.     char    * path, * view, * title, gokind;
  732.     char* kUpfolderTitle =  " <-- Parent folder";
  733.     
  734.     if (!outFile || !folderpath || !*folderpath) 
  735.         return -1;
  736.     short port= DGopher::StandardPort( DGopher::kGopherprot);
  737.     pathlen= StrLen(folderpath);
  738.     StrNCpy(namestore, folderpath, 240);
  739.     StrNCpy(pathstore, folderpath, 240);
  740.  
  741. #ifdef OS_MAC
  742. {
  743.     OSErr                 error = noErr;
  744.     long                     dirID = 0, theDirID;
  745.     short                 vRefNum = 0, itemIndex = 1; /* start with 1, then use what's returned */
  746.     CInfoPBRec         pb;
  747.     Boolean             isDirectory;
  748.     StringPtr         name;
  749.     DateTimeRec      dt;
  750.  
  751.     if (pathstore[pathlen-1] != ':') {
  752.         pathstore[pathlen++]= ':'; 
  753.         pathstore[pathlen]= 0;
  754.         }
  755.     nameat= pathstore+pathlen;
  756.     
  757.     Nlm_CtoPstr(namestore);
  758.     name= (StringPtr) namestore;
  759.     error = DetermineVRefNum( name, vRefNum, &pb.hFileInfo.ioVRefNum);
  760.     if ( error != noErr ) return error;
  761.     
  762.     error = GetDirID( vRefNum, dirID, name, &theDirID, &isDirectory);
  763.     if ( error != noErr ) return error;
  764.     else if ( !isDirectory ) return error;
  765.  
  766.     dirlist= new DList();
  767.     while ( error == noErr ) {  
  768.         pb.hFileInfo.ioNamePtr = name;
  769.         pb.hFileInfo.ioDirID = theDirID;
  770.         pb.hFileInfo.ioFDirIndex = itemIndex;
  771.         error = PBGetCatInfoSync(&pb);
  772.         if ( error == noErr ) {
  773.             if (itemIndex==1) {
  774.                 info= new DLoGoInfo( kTypeFolder, ":", kUpfolderTitle,
  775.                                         "application/gopher+-menu", "19530424134647", 0);
  776.                 dirlist->InsertLast( info);
  777.                 }
  778.             ++itemIndex;    /* prepare to get next item in directory */
  779.             
  780.             //title= pb.hFileInfo.ioNamePtr; == name
  781.             Nlm_PtoCstr( namestore);
  782.             //StrNCpy( nameat, namestore, 256-pathlen);
  783.             
  784.             if ( (pb.hFileInfo.ioFlAttrib & ioDirMask) != 0 ) { 
  785.                 gokind= kTypeFolder;
  786.                 view= "application/gopher+-menu";
  787.                 date= pb.dirInfo.ioDrMdDat;
  788.                 ksize= pb.dirInfo.ioDrNmFls;
  789.                 }
  790.                 
  791.             else {    
  792.                 //?? need to handle some special file types --
  793.                 // !! esp. need to map waissrc files to query type ??
  794.                 // -- map Mac Types: TEXT, ...? to gopher 0
  795.                 // map GIFf, PICT, BINA, ????, to various go types...
  796.                 // ?? use mapper classes !!?
  797.                 // !! need to check for .ASK blocks & ASK exec/scripts & handle that !?
  798.                 // !? need some form of .LINK file for changing go type/name !?
  799.                 
  800.                 gokind= kTypeFile;
  801.                 view= "text/plain";
  802.                 date= pb.hFileInfo.ioFlMdDat;
  803.                 ksize= pb.hFileInfo.ioFlLgLen / 1024;
  804.                 }
  805.                     
  806.             // Mod-Date: Thu Feb  4 13:46:47 1993 <19930204134647>
  807.             // write <19930204134647> == 1993 02 04 13 46 47
  808.             Secs2Date( date, &dt); 
  809.             sprintf( buf, "%04d%02d%02d%02d%02d%02d",  
  810.                             dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second);
  811.             info= new DLoGoInfo( gokind, namestore, NULL, view, buf, ksize);
  812.             dirlist->InsertLast( info);
  813.             }
  814.         }
  815. }
  816. #endif
  817.  
  818. #ifdef OS_UNIX
  819. {
  820.     // use readdir() routines to list directory
  821.     // and stat(filename,info) to get size/date/ of file
  822.     struct stat    statbuf;
  823.   DIR        * theDir;
  824.     struct dirent  *afile;
  825.     char         timeval[16];
  826.     struct tm *tmthing;
  827.     char    curdir[512];
  828.     char    *name1;
  829.   
  830.     if (pathstore[pathlen-1] != '/') {
  831.         pathstore[pathlen++]= '/'; 
  832.         pathstore[pathlen]= 0;
  833.         }
  834.     nameat= pathstore+pathlen;
  835.  
  836. #define USECHDIR 1
  837. #ifdef USECHDIR
  838.   getcwd( curdir, sizeof(curdir));
  839.     if (chdir(namestore)<0) return -1; // ??
  840.     theDir = opendir(".");
  841. #else
  842.     theDir = opendir(namestore);
  843. #endif
  844.     if (!theDir) return -1;
  845.     
  846.     dirlist= new DList();
  847.     for (afile = readdir(theDir); afile != NULL; afile = readdir(theDir)) {
  848.  
  849.       StrNCpy( namestore, afile->d_name, sizeof(namestore));
  850.         name1= namestore;
  851. #ifndef USECHDIR
  852.         StrNCpy( nameat, namestore, sizeof(pathstore)-pathlen);
  853.         name1= nameat;
  854. #endif
  855.  
  856.       if (! stat( name1, &statbuf)) {
  857.             if (StrCmp(namestore, ".")==0) {
  858.                 gokind= 0;
  859.                 view= NULL;
  860.                 }
  861.             else if (StrCmp(namestore, "..")==0) {
  862.                 gokind= kTypeFolder;
  863.                 view= "application/gopher+-menu";
  864.                 title= kUpfolderTitle;
  865.                 }
  866.             else if ( S_ISDIR(statbuf.st_mode)) {
  867.                 gokind= kTypeFolder;
  868.                 view= "application/gopher+-menu";
  869.                 }
  870.             else {
  871.                 gokind= kTypeFile;
  872.                 view= "text/plain";
  873.                 }
  874.             ksize= statbuf.st_size / 1024;
  875.             
  876.                 // Mod-Date: Thu Feb  4 13:46:47 1993 <19930204134647>
  877.             tmthing = localtime(&(statbuf.st_mtime));
  878.             strftime( timeval, sizeof(timeval), "%Y%m%d%H%M%S", tmthing);
  879.             sprintf( buf, "%s", timeval);
  880.             info= new DLoGoInfo( gokind, namestore, NULL, view, buf, ksize);
  881.             dirlist->InsertLast( info);
  882.             }
  883.         }
  884. #ifdef USECHDIR
  885.     chdir(curdir);
  886. #endif
  887. }
  888. #endif
  889.  
  890. #if defined(OS_DOS) || defined (OS_NT)
  891. {
  892.     struct  ffblk  finfo;
  893.     long        ltime;
  894.     struct    ftime    dt, *dtp;
  895.     
  896.     if ((pathstore[pathlen-1] != '\\') && (pathstore[pathlen-1] != '*')) {
  897.         pathstore[pathlen++]= '\\';   // "/" alone will get folder
  898.         pathstore[pathlen++]= '*';   // ?? "/*.*" will get folder' contents
  899.         pathstore[pathlen++]= '.';
  900.         pathstore[pathlen++]= '*';
  901.         pathstore[pathlen]= 0;
  902.     pathlen -= 3; // drop *.* for nameat !!
  903.         }
  904.     nameat= pathstore+pathlen;
  905.     
  906.     short err= findfirst( pathstore, &finfo, FA_RDONLY | FA_DIREC);
  907.     if (err) return -1;
  908.     dirlist= new DList();
  909.     while ( err==0 ) {
  910.     
  911.       StrNCpy( namestore, finfo.ff_name, sizeof(namestore));
  912.         //StrNCpy( nameat, namestore, sizeof(pathstore)-pathlen);
  913.       title= NULL;
  914.         if (StrCmp(namestore, ".")==0) {
  915.             gokind= 0;
  916.             view= NULL;
  917.             }
  918.         else if (StrCmp(namestore, "..")==0) {
  919.             gokind= kTypeFolder;
  920.             view= "application/gopher+-menu";
  921.             title= kUpfolderTitle;
  922.             }
  923.         else if ( finfo.ff_attrib & FA_DIREC) {
  924.             gokind= kTypeFolder;
  925.             view= "application/gopher+-menu";
  926.             }
  927.         else {
  928.             gokind= kTypeFile;
  929.             view= "text/plain";
  930.             }
  931.         ksize= finfo.ff_fsize / 1024;
  932.                 
  933.         // Mod-Date: Thu Feb  4 13:46:47 1993 <19930204134647>
  934.         // dos file times are weird
  935.         ltime= (finfo.ff_fdate << 16 + finfo.ff_ftime); // this is a GUESS !! probly wrong
  936.         //dt = (ftime) ltime;
  937.     MemCpy( &dt, <ime, sizeof(dt));
  938.         sprintf(buf, "%04d%02d%02d%02d%02d%02d",
  939.              (dt.ft_year + 1980), dt.ft_month, dt.ft_day, 
  940.                             dt.ft_hour, dt.ft_min, dt.ft_tsec*2);
  941.         info= new DLoGoInfo( gokind, namestore, title, view, buf, ksize);
  942.         dirlist->InsertLast( info);
  943.         
  944.         err= findnext( &finfo);
  945.         }
  946. }
  947. #endif
  948.  
  949.         // other OSes, don't know how to write directory
  950.         
  951.         
  952.     if (dirlist) {
  953.         // do various checks here:
  954.         // -- handle .ASK blocks
  955.         // -- handle WAIS index.{dct,dlm,doc,fmt,fni,fnn,hl,inv,src,query.lock}
  956.         //      and index_field_*.dct, index_field_*.inv
  957.         // -- handle any .LINK files
  958.  
  959.         short        startwais, stopwais, nwais= 0;
  960.         Boolean    gotwais;
  961.         char        indexname[256];
  962.         char        * name, * suf, * plus;
  963.         long        namelen, indexlen;
  964.         DLoGoInfo * info, * jinfo;
  965.         short i, n= dirlist->GetSize();
  966.  
  967.         dirlist->SortBy( dglLoGoCompareByName);
  968.         
  969.         for (i=0; i <= n; i++) {
  970.             gotwais= false;
  971.             if (i<n) {
  972.                 info= (DLoGoInfo*) dirlist->At(i);
  973.                 name= info->fName;
  974.                 suf= StrRChr( name, '.');
  975.                 namelen= StrLen(name);
  976.                 }
  977.                 
  978.             if (suf) {
  979.                 namelen= MIN( sizeof(indexname), namelen-StrLen(suf));
  980.                 suf++;
  981.                 
  982.                 if (StrICmp( suf, "ask") == 0 && i>0) {
  983.                     // handle .ask
  984.                     jinfo= (DLoGoInfo*) dirlist->At(i-1);
  985.                     if (StrNCmp(jinfo->fName, info->fName, namelen)==0) {
  986.                         jinfo->fIsAsk= true; // jinfo is the application for the .ask block !?
  987.                         info->fKind= 0; // don't show
  988.                         }
  989.                     }
  990.                     
  991. #if defined(OS_DOS) || defined(OS_NT)
  992.                  if (StrICmp( suf, "abs") == 0 && i>0)
  993. #else
  994.                 if (StrICmp( suf, "abstract") == 0 && i>0)
  995. #endif
  996.                     {
  997.                     jinfo= (DLoGoInfo*) dirlist->At(i-1);
  998.                     if (StrNCmp(jinfo->fName, info->fName, namelen)==0) {
  999.                         jinfo->fHasAbs= true; // jinfo is the application for the .abs block !?
  1000.                          info->fKind= 0; // don't show
  1001.                         }
  1002.                      }
  1003.                     
  1004.                 else if ( nwais && StrStr(name,indexname) == name) {
  1005.                     if ( ( namelen == indexlen || StrStr(name,"_field_") != NULL 
  1006.                         || StrICmp(suf,"lock") == 0) 
  1007.                     && (StrICmp( suf, "dlm")==0
  1008.                      || StrICmp( suf, "dct")==0    // this is for field, but watch for new nonfld !
  1009.                      || StrICmp( suf, "doc")==0
  1010.                      || StrICmp( suf, "fmt")==0
  1011.                      || StrICmp( suf, "fni")==0
  1012.                      || StrICmp( suf, "fnn")==0
  1013.                      || StrICmp( suf, "hl" )==0
  1014.                      || StrICmp( suf, "inv")==0
  1015.                      || StrICmp( suf, "lock")==0
  1016.                      || StrICmp( suf, "src")==0 )
  1017.                      ) {
  1018.                         nwais++;
  1019.                         gotwais= true;
  1020.                         }
  1021.                     }
  1022.                 else if ( StrICmp( suf, "dct")==0) { 
  1023.                     // always 1st in sorted list of wais names
  1024.                     // do this "dct" test after above, as "_field_" dct would conflict
  1025.                     if (nwais) {
  1026.                         StoreLoGoWais( startwais, i, dirlist);
  1027.                         nwais= 0;
  1028.                         }
  1029.                     gotwais= true;
  1030.                     nwais= 1;
  1031.                     startwais= i;
  1032.                     StrNCpy(indexname, name, namelen);
  1033.                     indexname[namelen]= 0;
  1034.                     indexlen= namelen;
  1035.                     }
  1036.                 }
  1037.                 
  1038.             if (nwais && !gotwais) {
  1039.                 StoreLoGoWais( startwais, i, dirlist);
  1040.                 nwais= 0;
  1041.                 }
  1042.             }
  1043.                     
  1044.         outFile->Open("w");
  1045.         for (i=0; i<n; i++) {
  1046.             info= (DLoGoInfo*) dirlist->At(i);
  1047.             if (info->fKind) {        
  1048.                 const char * title;    
  1049.                 StrNCpy( nameat, info->fName, sizeof(pathstore)-pathlen);
  1050.                 if (info->fIsAsk) plus= "\t?";
  1051.                 else if (info->fPlus) plus= "\t+"; 
  1052.                 else plus= "";
  1053.                 
  1054.                 sprintf(buf, "+INFO: %c%s\t%s\t%s\t%d%s\n", 
  1055.                                     info->fKind, info->fTitle, pathstore, kLocalhost, port, plus);
  1056.                 outFile->WriteLine( buf);
  1057.                 
  1058.                 sprintf(buf, "+ADMIN:\n Mod-Date: %s <%s>\n", "", info->fDate);
  1059.                 outFile->WriteLine( buf);
  1060.                 
  1061.                 sprintf(buf, "+VIEWS:\n %s En_US: <%dk>\n", info->fView, info->fSize);
  1062.                 outFile->WriteLine( buf);
  1063.                 
  1064.                 if (info->fIsAsk) {
  1065.                     StrNCpy( namestore, pathstore, sizeof(namestore));
  1066.                     StrNCat( namestore, ".ask", sizeof(namestore));
  1067.                     DFile* askf= new DFile( namestore);
  1068.                     if (askf->Exists()) {
  1069.                         char* buf1;
  1070.                         askf->Open("r");
  1071.                         outFile->WriteLine( "+ASK:\n");
  1072.                         buf[0]= ' ';
  1073.                         buf1= buf+1;
  1074.                         while (!askf->Eof()) {
  1075.                             *buf1= 0;
  1076.                             if (0 == askf->ReadLine( buf1, sizeof(buf)-1))
  1077.                              outFile->WriteLine( buf);
  1078.                             }
  1079.                         outFile->WriteLine( " \n");
  1080.                         askf->Close();
  1081.                         }
  1082.                     delete askf;
  1083.                     }
  1084.                     
  1085.  
  1086.                 if (info->fHasAbs) {
  1087.                     StrNCpy( namestore, pathstore, sizeof(namestore));
  1088.                     StrNCat( namestore, ".abstract", sizeof(namestore));
  1089.                     DFile* askf= new DFile( namestore);
  1090.                     if (askf->Exists()) {
  1091.                         char* buf1;
  1092.                         askf->Open("r");
  1093.                         outFile->WriteLine( "+ABSTRACT:\n");
  1094.                         buf[0]= ' ';
  1095.                         buf1= buf+1;
  1096.                         while (!askf->Eof()) {
  1097.                             *buf1= 0;
  1098.                             if (0 == askf->ReadLine( buf1, sizeof(buf)-1))
  1099.                                 outFile->WriteLine( buf);
  1100.                             }
  1101.                         outFile->WriteLine( " \n");
  1102.                         askf->Close();
  1103.                         }
  1104.                     delete askf;
  1105.                     }
  1106.                     
  1107.                 }
  1108.             delete info;
  1109.             }
  1110.         //outFile->Close();
  1111.         delete dirlist;
  1112.         return 0;
  1113.         }
  1114.     else
  1115.         return -1;
  1116. }
  1117.  
  1118.  
  1119.  
  1120.